home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Dev / GNU-TILE-FORTH.lha / src / kernel.h < prev    next >
C/C++ Source or Header  |  1992-05-19  |  12KB  |  658 lines
  1. /*
  2.   C BASED FORTH-83 MULTI-TASKING KERNEL DEFINITIONS
  3.  
  4.   Copyright (C) 1988-1990 by Mikael R.K. Patel
  5.  
  6. */
  7.  
  8.  
  9. /* INCLUDED SYSTEM FUNCTIONS */
  10.  
  11. #include <strings.h>
  12.  
  13.  
  14. /* TYPING SYSTEM AND MISC. STRING MACROS */
  15.  
  16. #define VOID void
  17.  
  18. typedef char*  PTR8;
  19. typedef short* PTR16;
  20. typedef long*  PTR32;
  21.  
  22. typedef VOID (*SUBR)();
  23.  
  24. #define NIL 0
  25.  
  26. typedef long BOOL;
  27.  
  28. #define TRUE  ((BOOL) -1)
  29. #define FALSE ((BOOL)  0)
  30.  
  31. typedef unsigned       NUM;
  32. typedef unsigned char  NUM8;
  33. typedef unsigned short NUM16;
  34. typedef unsigned long  NUM32;
  35.  
  36. typedef int   INT;
  37. typedef char  INT8;
  38. typedef short INT16;
  39. typedef long  INT32;
  40.  
  41. typedef float  FLOAT32;
  42. typedef double FLOAT64;
  43.  
  44. typedef char  CHAR;
  45. typedef char* CSTR;
  46. typedef char* PSTR;
  47.  
  48. #define STREQ(s1, s2) ((*(CSTR) s1 == *(CSTR) s2) && \
  49.                (*(CSTR) s1 + 1 == *(CSTR) s2 + 1) && \
  50.                !(strcmp((CSTR) s1, (CSTR) s2)))
  51.  
  52.  
  53. /* QUEUE DEFINITION */
  54.  
  55. typedef struct _queue {
  56.     struct _queue *succ, *pred;
  57. } queue, *QUEUE;
  58.  
  59.  
  60. /* TASK DEFINITION */
  61.  
  62. typedef struct {
  63.     queue queue;
  64.     INT32 status;
  65.     PTR32 sp;
  66.     PTR32 s0;
  67.     PTR32 ip;
  68.     PTR32 rp;
  69.     PTR32 r0;
  70.     PTR32 fp;
  71.     PTR32 ep;
  72. } task_header;
  73.  
  74. typedef struct {
  75.     queue queue;
  76.     INT32 status;
  77.     PTR32 sp;
  78.     PTR32 s0;
  79.     PTR32 ip;
  80.     PTR32 rp;
  81.     PTR32 r0;
  82.     PTR32 fp;
  83.     PTR32 ep;
  84.     INT32 users[1];
  85. } task, *TASK;
  86.  
  87.  
  88. /* TASK STATUS FIELD VALUES: ENUMERATE */
  89.  
  90. #define TERMINATED 0
  91. #define READY      1
  92. #define RUNNING    2
  93. #define IOWAITING  3
  94. #define WAITING    4
  95. #define DELAYED    5
  96.  
  97.  
  98. /* VOCABULARY ENTRY DEFINITION, TYPES, AND MODES */
  99.  
  100. typedef struct _entry {
  101.     struct _entry *link;
  102.     CSTR  name;
  103.     INT32 mode;
  104.     INT32 code;
  105.     INT32 parameter;
  106. } entry, *ENTRY;
  107.  
  108.  
  109. /* ENTRY MODE VALUES: SET */
  110.  
  111. #define NORMAL      0
  112. #define IMMEDIATE   1
  113. #define EXECUTION   2
  114. #define COMPILATION 4
  115. #define HIDDEN      6
  116. #define PRIVATE     8
  117.  
  118.  
  119. /* ENTRY CODE VALUES: ENUMERATES */
  120.  
  121. #define CODE       0
  122. #define COLON      1
  123. #define VARIABLE   2
  124. #define CONSTANT   3
  125. #define VOCABULARY 4
  126. #define CREATE     5
  127. #define USER       6
  128. #define LOCAL      7
  129. #define FORWARD    8
  130. #define FIELD      9
  131. #define EXCEPTION  10
  132.  
  133.  
  134. /* ENTRY VISIBILITY MACRO */
  135.  
  136. #define visible(e, v) \
  137.     (!(((e -> mode & COMPILATION) && (!state.parameter)) || \
  138.        ((e -> mode & EXECUTION) && (state.parameter))  || \
  139.        ((e -> mode & PRIVATE) && (v != current))))
  140.  
  141.  
  142. /* NORMAL ENTRY GENERATORS */
  143.  
  144. #define NORMAL_CONSTANT(v, l, n, p) \
  145.     static entry v = \
  146.        {(ENTRY) &l, n, NORMAL, CONSTANT, p};
  147.  
  148. #define NORMAL_VARIABLE(v, l, n, p) \
  149.     static entry v = \
  150.        {(ENTRY) &l, n, NORMAL, VARIABLE, p};
  151.  
  152.  
  153. /* VOCABULARY ENTRY DEFINITION */
  154.  
  155. typedef struct {
  156.     ENTRY link;
  157.     CSTR  name;
  158.     INT32 mode;
  159.     INT32 code;
  160.     ENTRY last;
  161.     ENTRY recognizer;
  162. } vocabulary_entry, *VOCABULARY_ENTRY;
  163.  
  164. #define NORMAL_VOCABULARY(v, l, n, p, r) \
  165.     static vocabulary_entry v = \
  166.        {(ENTRY) &l, n, NORMAL, VOCABULARY, (ENTRY) p, (ENTRY) r};
  167.  
  168.  
  169. /* CODE ENTRY DEFINITION */
  170.  
  171. typedef struct {
  172.     ENTRY link;
  173.     CSTR name;
  174.     INT32 mode;
  175.     INT32 code;
  176.     SUBR subr;
  177. } code_entry, *CODE_ENTRY;
  178.  
  179.  
  180. #define NORMAL_CODE(v, l, n, s) \
  181.     static code_entry v = \
  182.        {(ENTRY) &l, n, NORMAL, CODE, s};
  183.  
  184. #define IMMEDIATE_CODE(v, l, n, s) \
  185.     static code_entry v = \
  186.        {(ENTRY) &l, n, IMMEDIATE, CODE, s};
  187.  
  188. #define COMPILATION_CODE(v, l, n, s) \
  189.     static code_entry v = \
  190.        {(ENTRY) &l, n, COMPILATION, CODE, s};
  191.  
  192. #define EXECUTION_CODE(v, l, n, s) \
  193.     static code_entry v = \
  194.        {(ENTRY) &l, n, EXECUTION, CODE, s};
  195.  
  196. #define COMPILATION_IMMEDIATE_CODE(v, l, n, s) \
  197.     static code_entry v = \
  198.        {(ENTRY) &l, n, COMPILATION + IMMEDIATE, CODE, s};
  199.  
  200.  
  201. /* UNIVERSAL VALUE */
  202.  
  203. typedef union {
  204.     BOOL             BOOL;
  205.     NUM32            NUM32;
  206.     INT32            INT32;
  207.     FLOAT32          FLOAT32;
  208.     CSTR             CSTR;
  209.     PTR8             PTR8;
  210.     PTR16            PTR16;
  211.     PTR32            PTR32;
  212.     SUBR             SUBR;
  213.     QUEUE            QUEUE;
  214.     TASK             TASK;
  215.     ENTRY            ENTRY;
  216.     CODE_ENTRY       CODE_ENTRY;
  217.     VOCABULARY_ENTRY VOCABULARY_ENTRY;
  218. } UNIV, *PTR;
  219.  
  220.  
  221. /* STACK MACROS */
  222.  
  223. #define sinit() sp = s0
  224. #define spop(t) tos.t; tos = *sp++
  225. #define spush(e, t) *(--sp) = tos; tos.t = e
  226. #define snth(n) sp[n]
  227. #define sdrop() tos = *sp++
  228. #define sndrop(n) sp += (n); tos = *sp++
  229. #define snip() sp++
  230. #define sdup() *(--sp) = tos
  231. #define sover() { register UNIV t; t = *sp; *(--sp) = tos; tos = t; }
  232. #define stuck() { register UNIV t; t = *sp; *sp = tos; *(--sp) = t; }
  233. #define sswap() { register UNIV t; t = tos; tos = sp[0]; sp[0] = t; }
  234. #define srot()  { register UNIV t; t = tos; tos = sp[1]; sp[1] = sp[0]; sp[0] = t; }
  235. #define sdashrot() { register UNIV t; t = tos; tos = sp[0]; sp[0] = sp[1]; sp[1] = t; }
  236.  
  237. #define coerce(f, t) tos.t = (t) tos.f
  238. #define unary(o, t) tos.t = o tos.t
  239. #define binary(o, t) tos.t = sp++ -> t o tos.t
  240. #define compare(o, t) tos.BOOL = (tos.t o ? TRUE : FALSE)
  241. #define relation(o, t) tos.INT32 = (sp++ -> t o tos.t ? TRUE : FALSE)
  242.  
  243. #define rinit() rp = r0
  244. #define rpop() *rp++
  245. #define rpush(e) *(--rp) = (INT32) e
  246. #define rnth(n) rp[n]
  247. #define rndrop(n) rp += n    
  248.  
  249.  
  250. /* THREADING ALIGNMENT MACRO */
  251.  
  252. #define align(p) p = (PTR32) ((INT32) ((PTR8) p + 3) & -4)
  253.  
  254.  
  255. /* THREADED BRANCH, RETURN MACRO */
  256.  
  257. #define fskip() ip++
  258. #define fbranch(d) ip = (PTR32) ((PTR8) ip + (d))
  259. #define fjump(a) ip = (PTR32) (a)
  260. #define fsemicolon() fjump(rpop())
  261. #define fdoes() current -> last -> code = (INT32) ip; fsemicolon()
  262.  
  263.  
  264. /* ARGUMENT AND LOCAL VARIABLE FRAME MACRO */
  265.  
  266. #define flink() \
  267. { \
  268.     spush(fp, PTR32); \
  269.     fp = (PTR32) sp + *ip++; \
  270.     sp = sp - *ip++; \
  271.     rpush(sp); \
  272. } 
  273.  
  274. #define funlink() \
  275. { \
  276.     register PTR32 t; \
  277.     register PTR32 s; \
  278.     t = (PTR32) rpop(); \
  279.     if (t == (PTR32) sp) { \
  280.     sp = (PTR) fp; \
  281.     fp = tos.PTR32; \
  282.     sdrop(); \
  283.     } \
  284.     else { \
  285.     s = fp; \
  286.     fp = (PTR32) *--t; \
  287.     while (t > (PTR32) sp) *--s = *--t; \
  288.     sp = (PTR) s; \
  289.     } \
  290. }    
  291.  
  292. #define fcatch() \
  293. { \
  294.     PTR32 body; \
  295.     body = spop(PTR32); \
  296.     rpush(tos.INT32); \
  297.     rpush(sp); \
  298.     rpush(ip); \
  299.     rpush(fp); \
  300.     rpush(ep); \
  301.     ep = rp; \
  302.     fjump(body); \
  303. }
  304.  
  305. #define fthrow() \
  306. { \
  307.     ep = (PTR32) rpop(); \
  308.     rndrop(4); \
  309.     fsemicolon() ; \
  310. }
  311.     
  312. /* EXTERN FORWARD DECLARATIONS */
  313.  
  314. extern INT32 verbose;
  315. extern INT32 quited;
  316. extern INT32 running;
  317. extern INT32 tasking;
  318.  
  319. extern TASK tp;
  320. extern TASK foreground;
  321.  
  322. extern UNIV tos;
  323. extern PTR  sp;
  324. extern PTR  s0;
  325.  
  326. extern PTR32 ip;
  327. extern PTR32 rp;
  328. extern PTR32 r0;
  329.  
  330. extern PTR32 fp;
  331. extern PTR32 ep;
  332.  
  333. extern PTR32 dictionary;
  334. extern PTR32 dp;
  335.  
  336. extern vocabulary_entry forth;
  337.  
  338. TASK  make_task();
  339. ENTRY make_entry();
  340.  
  341. VOID kernel_initiate();
  342. VOID kernel_finish();
  343.  
  344. VOID doinner();
  345. VOID docommand();
  346. VOID docall();
  347. VOID doappend();
  348.  
  349.   
  350. /* COMPILER EXTENSIONS */
  351.  
  352. VOID doparenbranch();
  353. VOID doparenqbranch();
  354. VOID doparendo();
  355. VOID doparenqdo();
  356. VOID doparenloop();
  357. VOID doparenplusloop();
  358. VOID doparenliteral();
  359. VOID doparendotquote();
  360. VOID doparenabortquote();
  361. VOID doparensemicolon();
  362. VOID doparendoes();
  363. VOID dothread();
  364. VOID dounthread();
  365. VOID doforwardmark();
  366. VOID dobackwardmark();
  367. VOID doforwardresolve();
  368. VOID dobackwardresolve();
  369.  
  370.  
  371. /* LOCAL VARIABLES AND ARGUMENT BINDING */
  372.  
  373. VOID dounlinklocals();
  374. VOID doparenlink()  ;
  375. VOID doparenunlink()  ;
  376. VOID doparenunlinksemicolon() ;
  377. VOID doparenunlinkdoes();
  378. VOID doparenlocal();
  379. VOID doparenlocalstore();
  380. VOID doparenlocalfetch();
  381. VOID doassignlocal();
  382. VOID dolocalreturn();
  383. VOID docurlebracket();
  384.  
  385.  
  386. /* NULL TERMINATED STRING */
  387.  
  388. VOID doparenquote();
  389. VOID doquote();
  390. VOID doslength();
  391. VOID dosdup();
  392. VOID dosequal();
  393. VOID doscompare();
  394. VOID doscat();
  395. VOID dosprint();
  396.  
  397.  
  398. /* FLOATING POINT NUMBERS */
  399.  
  400. VOID doitof();
  401. VOID doftoi();
  402. VOID dofplus();
  403. VOID dofminus();
  404. VOID doftimes();
  405. VOID dofdivide();
  406. VOID dofonedivide();
  407. VOID dofnegate();
  408. VOID dofdot();
  409. VOID doqfloat();
  410.  
  411.  
  412. /* MEMORY MANAGEMENT */
  413.  
  414. VOID domalloc();
  415. VOID dorealloc();
  416. VOID dofree();
  417.  
  418.  
  419. /* DOUBLE LINKED LISTS */
  420.  
  421. VOID doqemptyqueue();
  422. VOID doenqueue();
  423. VOID dodequeue();
  424.  
  425.  
  426. /* MULTI-TASKING EXTENSIONS */
  427.  
  428. VOID douser();
  429. VOID dotask();
  430. VOID dofork();
  431. VOID doresume();
  432. VOID doschedule();
  433. VOID dodetach();
  434. VOID doterminate();
  435.  
  436.  
  437. /* SIGNAL AND EXCEPTION MANAGEMENT */
  438.  
  439. VOID donewexception();
  440. VOID doparenexceptionsemicolon();
  441. VOID doparenexceptionunlinksemicolon();
  442. VOID doparenexception();
  443. VOID doexception();
  444. VOID doraise();
  445.  
  446.  
  447. /* KERNEL VOCABULARY */
  448.  
  449. VOID doboolean();
  450. VOID donot();
  451. VOID doand();
  452. VOID door();
  453. VOID doxor();
  454. VOID doqwithin();
  455.  
  456. VOID dodepth();
  457. VOID dodrop();
  458. VOID donip();
  459. VOID doswap();
  460. VOID dorot();
  461. VOID dodashrot();
  462. VOID doroll();
  463. VOID doqdup();
  464. VOID dodup();
  465. VOID doover();
  466. VOID dotuck();
  467.  
  468. VOID dotor();
  469. VOID dofromr();
  470. VOID docopyr();
  471.  
  472. VOID dotwotor();
  473. VOID dotwofromr();
  474. VOID dotwodrop();
  475. VOID dotwoswap();
  476. VOID dotworot();
  477. VOID dotwodup();
  478. VOID dotwoover();
  479.  
  480. VOID dolessthan();
  481. VOID doequals();
  482. VOID dogreaterthan();
  483. VOID dozeroless();
  484. VOID dozeroequals();
  485. VOID dozerogreater();
  486. VOID doulessthan();
  487.  
  488. VOID doplus();
  489. VOID dominus();
  490. VOID dooneplus();
  491. VOID dooneminus();
  492. VOID dotwoplus();
  493. VOID dotwominus();
  494. VOID dotwotimes();
  495. VOID doleftshift();
  496. VOID dotimes();
  497. VOID doumtimes();
  498. VOID doumdividemod();
  499. VOID dotwodivide();
  500. VOID dorightshift();
  501. VOID dodivide();
  502. VOID domod();
  503. VOID dodividemod();
  504. VOID dotimesdividemod();
  505. VOID dotimesdivide();
  506. VOID domin();
  507. VOID domax();
  508. VOID doabs();
  509. VOID donegate();
  510.  
  511. VOID dofetch();
  512. VOID dostore();
  513. VOID dowfetch();
  514. VOID dolesswfetch();
  515. VOID dowstore();
  516. VOID docfetch();
  517. VOID doclessfetch();
  518. VOID docstore();
  519. VOID doffetch();
  520. VOID dolessffetch();
  521. VOID dofstore();
  522. VOID dobfetch();
  523. VOID dobstore();
  524. VOID dotwostore();
  525. VOID dotwofetch();
  526. VOID doplusstore();
  527.  
  528. VOID docmove();
  529. VOID docmoveup();
  530. VOID dofill();
  531. VOID docount();
  532. VOID dobounds();
  533. VOID dodashtrailing();
  534. VOID dodashmatch();
  535.  
  536. VOID dobinary();
  537. VOID dooctal();
  538. VOID dodecimal();
  539. VOID dohex();
  540. VOID doconvert();
  541. VOID dolesssharp();
  542. VOID dosharp();
  543. VOID dosharps();
  544. VOID dohold();
  545. VOID dosign();
  546. VOID dosharpgreater();
  547. VOID doqnumber();
  548.  
  549. VOID dodo();
  550. VOID doqdo();
  551. VOID doloop();
  552. VOID doplusloop();
  553. VOID doleave();
  554. VOID doi();
  555. VOID doj();
  556. VOID doif();
  557. VOID doelse();
  558. VOID dothen();
  559. VOID docase();
  560. VOID doof();
  561. VOID doendof();
  562. VOID doendcase();
  563. VOID dobegin();
  564. VOID dountil();
  565. VOID dowhile();
  566. VOID dorepeat();
  567. VOID doagain();
  568. VOID dorecurse();
  569. VOID dotailrecurse();
  570. VOID doexit();
  571. VOID doexecute();
  572. VOID dobye();
  573.  
  574. VOID dodot();
  575. VOID dodotr();
  576. VOID doudot();
  577. VOID doudotr();
  578. VOID doascii();
  579. VOID dodotquote();
  580. VOID dodotparen();
  581. VOID dodots();
  582. VOID docr();
  583. VOID doemit();
  584. VOID dotype();
  585. VOID dospace();
  586. VOID dospaces();
  587.  
  588. VOID dokey();
  589. VOID doexpect();
  590. VOID doline();
  591. VOID dosource();
  592.  
  593. VOID doforth83();
  594. VOID dointerpret();
  595. VOID doquit();
  596. VOID doabort();
  597. VOID doabortquote();
  598.  
  599. VOID dohere();
  600. VOID dotobody();
  601. VOID dodotname();
  602. VOID docells();
  603. VOID docellplus();
  604. VOID dosharpif();
  605. VOID dosharpelse();
  606. VOID dosharpthen();
  607. VOID dosharpifdef();
  608. VOID dosharpifundef();
  609. VOID dosharpinclude();
  610. VOID dosharppath();
  611. VOID doparen();
  612. VOID dobackslash();
  613.  
  614. VOID docomma();
  615. VOID doallot();
  616. VOID doalign();
  617. VOID dodoes();
  618. VOID doimmediate();
  619. VOID doexecution();
  620. VOID docompilation();
  621. VOID doprivate();
  622. VOID dorecognizer();
  623. VOID dobracketcompile();
  624. VOID docompile();
  625. VOID doqcompile();
  626. VOID docompiling();
  627. VOID doliteral();
  628. VOID doleftbracket();
  629. VOID dorightbracket();
  630. VOID doword();
  631.  
  632. VOID dolast();
  633. VOID dodefinitions();
  634. VOID doonly();
  635. VOID doseal();
  636. VOID dorestore();
  637. VOID dotick();
  638. VOID dobrackettick();
  639. VOID dolookup() ;
  640. VOID dofind();
  641. VOID dorecognize();
  642. VOID doforget();
  643. VOID dowords();
  644. VOID doentry();
  645. VOID doforward();
  646. VOID docode();
  647. VOID docolon();
  648. VOID dosemicolon();
  649. VOID docreate();
  650. VOID dovariable();
  651. VOID doconstant();
  652. VOID dovocabulary();
  653. VOID dofield();
  654.  
  655. #ifdef PROFILE
  656. VOID docollision();
  657. #endif
  658.